1,604 research outputs found
Comprehensive Monitor-Oriented Compensation Programming
Compensation programming is typically used in the programming of web service
compositions whose correct implementation is crucial due to their handling of
security-critical activities such as financial transactions. While traditional
exception handling depends on the state of the system at the moment of failure,
compensation programming is significantly more challenging and dynamic because
it is dependent on the runtime execution flow - with the history of behaviour
of the system at the moment of failure affecting how to apply compensation. To
address this dynamic element, we propose the use of runtime monitors to
facilitate compensation programming, with monitors enabling the modeller to be
able to implicitly reason in terms of the runtime control flow, thus separating
the concerns of system building and compensation modelling. Our approach is
instantiated into an architecture and shown to be applicable to a case study.Comment: In Proceedings FESCA 2014, arXiv:1404.043
Monitoring distributed systems with distributed polyLarva
polyLarva is a language-agnostic runtime verification tool, which converts a polyLarvaScript into a monitor for a given system. While an implementation for polyLarva exists, the language and its compilation have not been formalised. We therefore present a formal implementation-independent model which describes the behaviour of polyLarvaScript, comprising of the uLarvaScript grammar and of a set of operational semantics. This allows us to prove important properties, such as determinism, and also enables us to reason about ways of re-designing the tool in a more scalable way. We also present a collection of denotational mappings for uLarvaScript converting the constructs of our grammar into constructs of a formal actor-based model, thus providing an Actor semantics for uLarvaScript. We are also able to prove certain correctness properties of the denotational translation such as that the denoted Actors behave in a way which corresponds to the behaviour described by our implementation-independent model. We finally present distPolyLarva, a prototype implementation of the distributed polyLarva tool, which implements the new actor-based semantics over a language that can natively handle distribution and concurrency called Erlang.peer-reviewe
Verifying Web Applications: From Business Level Specifications to Automated Model-Based Testing
One of reasons preventing a wider uptake of model-based testing in the
industry is the difficulty which is encountered by developers when trying to
think in terms of properties rather than linear specifications. A disparity has
traditionally been perceived between the language spoken by customers who
specify the system and the language required to construct models of that
system. The dynamic nature of the specifications for commercial systems further
aggravates this problem in that models would need to be rechecked after every
specification change. In this paper, we propose an approach for converting
specifications written in the commonly-used quasi-natural language Gherkin into
models for use with a model-based testing tool. We have instantiated this
approach using QuickCheck and demonstrate its applicability via a case study on
the eHealth system, the national health portal for Maltese residents.Comment: In Proceedings MBT 2014, arXiv:1403.704
Device-Centric Monitoring for Mobile Device Management
The ubiquity of computing devices has led to an increased need to ensure not
only that the applications deployed on them are correct with respect to their
specifications, but also that the devices are used in an appropriate manner,
especially in situations where the device is provided by a party other than the
actual user. Much work which has been done on runtime verification for mobile
devices and operating systems is mostly application-centric, resulting in
global, device-centric properties (e.g. the user may not send more than 100
messages per day across all applications) being difficult or impossible to
verify. In this paper we present a device-centric approach to runtime verify
the device behaviour against a device policy with the different applications
acting as independent components contributing to the overall behaviour of the
device. We also present an implementation for Android devices, and evaluate it
on a number of device-centric policies, reporting the empirical results
obtained.Comment: In Proceedings FESCA 2016, arXiv:1603.0837
Dynamic analysis overview and a proposed verification tool for temporal properties in security-critical software
The need for correct software is increasing as computers are proliferating in every aspect of our lives. Dynamic analysis is a possible way of
increasing the reliability of software by introducing a monitoring and verification mechanism over and above a computer system, so that if under
some unprecedented circumstance, any of its specifications are violated,
an alarm will be raised. This paper gives an overview of the literature
in the subject and also puts forward a proposal of further research and
investigation which seems to be very promising.peer-reviewe
Extensible Technology-Agnostic Runtime Verification
With numerous specialised technologies available to industry, it has become
increasingly frequent for computer systems to be composed of heterogeneous
components built over, and using, different technologies and languages. While
this enables developers to use the appropriate technologies for specific
contexts, it becomes more challenging to ensure the correctness of the overall
system. In this paper we propose a framework to enable extensible technology
agnostic runtime verification and we present an extension of polyLarva, a
runtime-verification tool able to handle the monitoring of
heterogeneous-component systems. The approach is then applied to a case study
of a component-based artefact using different technologies, namely C and Java.Comment: In Proceedings FESCA 2013, arXiv:1302.478
Organising LTL monitors over distributed systems with a global clock
Users wanting to monitor distributed systems often prefer to abstract
away the architecture of the system, allowing them to directly specify correctness properties on the global system behaviour. To support this abstraction, a
compilation of the properties would not only involve the typical choice of monitoring algorithm, but also the organisation of submonitors across the component
network. Existing approaches, considered in the context of LTL properties over
distributed systems with a global clock, include the so-called orchestration and
migration approaches. In the orchestration approach, a central monitor receives
the events from all subsystems. In the migration approach, LTL formulae transfer
themselves across subsystems to gather local information.
We propose a third way of organising submonitors: choreography — where monitors are orgnized as a tree across the distributed system, and each child feeds
intermediate results to its parent. We formalise this approach, proving its correctness and worst case performance, and report on an empirical investigation
comparing the three approaches on several concerns of decentralised monitoring.peer-reviewe
An event-driven language for cartographic modelling of knowledge in software development organisations
With software engineering now being considered a
fully-fledged knowledge industry in which the most valuable asset to
an organisation is the knowledge held by its employees [BD08], high
staff turnover rates are becoming increasingly worrying. If software
engineering organisations are to maintain their competitive edge,
they need to ensure that their intellectual capital continues to grow
and is not lost as people move in and out of their employ.
In this paper, the authors present work involving the formalisation of a language that enables organisations to create and analyse
maps of their organisational knowledge. In a more elaborate version
of the traditional yellow-pages approach utilised in the cartographic
school of thought, the proposed language models various relationships between knowledge assets, uses an event-driven mechanism
to determine who knows what within the organisation, and finally
provides metrics for detecting three types of risk related to knowledge management in modern software engineering. A three month
evaluation of the language is also outlined and results discussed.peer-reviewe
Organising LTL monitors over distributed systems with a global clock
Users wanting to monitor distributed systems often prefer to abstract
away the architecture of the system, allowing them to directly specify correctness properties on the global system behaviour. To support this abstraction, a
compilation of the properties would not only involve the typical choice of monitoring algorithm, but also the organisation of submonitors across the component
network. Existing approaches, considered in the context of LTL properties over
distributed systems with a global clock, include the so-called orchestration and
migration approaches. In the orchestration approach, a central monitor receives
the events from all subsystems. In the migration approach, LTL formulae transfer
themselves across subsystems to gather local information.
We propose a third way of organising submonitors: choreography — where monitors are orgnized as a tree across the distributed system, and each child feeds
intermediate results to its parent. We formalise this approach, proving its correctness and worst case performance, and report on an empirical investigation
comparing the three approaches on several concerns of decentralised monitoring.peer-reviewe
- …